﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using System.Windows.Media.Imaging;
using Parsowanie;
using Portfel.IS;
using Portfel.SerializeModels;
using Portfel.enums;
using Telerik.Windows.Controls;
using Telerik.Windows.Data;

namespace Portfel.ViewModels
{
    public class MainAktywaViewModel : ViewModelBase
    {
        private ObservableCollection<AktywaViewModel> items;

        /// <summary>
        /// Initializes the items.
        /// </summary>



        public ObservableCollection<AktywaViewModel> Items
        {
            get
            {
                if (this.items == null)
                {
                    this.InitializeItems();
                }
                return this.items;
            }
            private set
            {
                this.items = value;
                this.OnPropertyChanged("Items");
            }
        }

        public string Wartość
        {
            get
            {
                if (wartość == null)
                {
                    wartość =
                    "";
                }
                return this.wartość;
            }
            private set
            {
                this.wartość = value;
                this.OnPropertyChanged("Wartość");
            }
        }

        private List<Aktywa> _aktywas;

        public List<Aktywa> Aktywas
        {
            get { return _aktywas ?? (_aktywas = IsolatedStorageHelper.ReadFromXml<List<Aktywa>>(IsolatedStorageHelper.Aktywa)); }
            private set { _aktywas = value; }
        }

        public void InitializeItems()
        {
            var items = new ObservableCollection<AktywaViewModel>();
            List<SecurityIndice> akcje = null;
            List<SecurityIndice> obligacje = null;
            if (Aktywas.Any(aktywa => aktywa.Typ == TypPapieru.Akcja))
            {
                akcje = IsolatedStorageHelper.ReadFromXml<List<SecurityIndice>>(IsolatedStorageHelper.AkcjeFile);
            }
            if (Aktywas.Any(aktywa => aktywa.Typ == TypPapieru.Obligacja))
            {
                obligacje = IsolatedStorageHelper.ReadFromXml<List<SecurityIndice>>(IsolatedStorageHelper.ObligacjeFile);
            }

            foreach (var s in Aktywas)
            {
                SecurityIndice obecny = null;
                switch (s.Typ)
                {
                    case TypPapieru.Akcja:
                        obecny = akcje.First(a => a.Security.SecurityName == s.Name);
                        break;
                    case TypPapieru.Obligacja:
                        obecny = obligacje.First(a => a.Security.SecurityName == s.Name);
                        break;
                }

                var wartość = obecny.Rate * s.Ilość;

                Brush color;
                if (wartość < s.Koszt)
                    color = new SolidColorBrush(Colors.Red);
                else if (s.Koszt < wartość)
                    color = new SolidColorBrush(Colors.Green);
                else
                    color = new SolidColorBrush(Colors.Blue);
                var zmiana = (wartość - s.Koszt);
                items.Add(new AktywaViewModel
                               {
                                   Color = color,
                                   Ilość = s.Ilość.ToString("#"),
                                   Koszt = (double.IsNaN(s.Koszt) ? 0.0 : s.Koszt).ToString("#0.00"),
                                   Title = s.Name,
                                   Wartość = wartość.ToString("#0.00"),
                                   Group = s.Typ.ToString(),
                                   Zmiana = zmiana.ToString("#0.00"),
                                   IsEditable = s.IsNew,
                                   ZmianaProcent = (double.IsNaN(s.Koszt) ? 0.0 : (zmiana / s.Koszt / 100)).ToString("+0.00%;-0.00%;0.00%"),

                               });
            }

            Items = items;
            Wartość = items.Sum(model => double.Parse(model.Wartość)).ToString("#0.00");
        }


        private List<string> groupPicker;
        public List<string> GroupPicker
        {
            get
            {
                if (groupPicker == null)
                {
                    this.InitializeGroupPickersA();
                }
                return groupPicker;

            }
            private set { groupPicker = value; }
        }

        private void InitializeGroupPickersA()
        {
            groupPicker = Items.Select(i => i.Group).Distinct().ToList();
        }

        #region GroupDescriptors
        private List<DataDescriptor> groupDescriptors;
        private string wartość;

        /// <summary>
        /// Gets the group descriptors.
        /// </summary>
        public List<DataDescriptor> GroupDescriptors
        {
            get
            {
                if (this.groupDescriptors == null)
                {
                    this.InitializeGroupDescriptors();
                }
                return this.groupDescriptors;
            }
            private set
            {
                this.groupDescriptors = value;
            }
        }

        /// <summary>
        /// Initializes the group descriptors that will be used for grouping in RadJumpList.
        /// </summary>
        private void InitializeGroupDescriptors()
        {
            this.groupDescriptors = new List<DataDescriptor>();
            var groupDescriptor = new GenericGroupDescriptor<AktywaViewModel, string>(item => item.Group);
            this.groupDescriptors.Add(groupDescriptor);
        }
        #endregion
    }
}
